Le présent manuel a pour seul objectif de guider les étudiants dans leur initiation au logiciel R. Ce dernier demeure un outil vaste et complexe, dont l’apprentissage est un processus continu en raison des mises à jour fréquentes et du développement constant de nouveaux packages. Ce document ne prétend nullement se substituer aux ouvrages spécialisés qui explorent le sujet de manière exhaustive et que nous recommandons vivement pour un apprentissage approfondi. Néanmoins, nous espérons que le résumé présenté ci-dessous offrira aux novices une introduction aux fonctions élémentaires de R et facilitera leur prise en main du logiciel.
R: un aperçu
R est un langage de programmation et un environnement informatique spécialisé dans le calcul statistique, l’analyse de données et leur visualisation. Initialement développé au milieu des années 1990 par Ross Ihaka et Robert Gentleman aux Laboratoires Bell, R est, depuis 1997, maintenu et organisé par la R Development Core Team. Ce logiciel, distribué sous licence Open Source, fait partie du projet GNU et est compatible avec les systèmes d’exploitation Unix, Macintosh et Windows.
R se distingue comme un outil d’apprentissage et d’application des statistiques, offrant un cadre cohérent et extensible pour l’analyse des données. Sa nature Open Source garantit une accessibilité universelle, le rendant adapté aussi bien aux étudiants qu’aux chercheurs, analystes et data scientists. Grâce à sa flexibilité et à ses nombreuses bibliothèques (ou packages), R est particulièrement prisé pour des domaines tels que les statistiques avancées et le machine learning. Il permet la création de visualisations sophistiquées, ce qui renforce son utilité dans divers contextes. Enfin, R bénéficie d’une vaste communauté d’utilisateurs et de milliers de packages disponibles via le CRAN (Comprehensive R Archive Network), ce qui en fait un outil puissant, gratuit et en constante évolution.
RStudio : un environnement intégré pour R
RStudio est un environnement de développement intégré (IDE=integrated development environment) conçu spécifiquement pour faciliter la programmation en R. Il propose une interface conviviale et intuitive qui simplifie l’utilisation de R en organisant efficacement les différents aspects du travail, comme l’écriture de code, l’exécution des scripts, l’analyse des données et la visualisation.
RStudio est régulièrement mis à jour, et lorsque votre ordinateur est connecté à Internet, l’IDE signale la disponibilité d’une nouvelle version. Il est vivement recommandé de maintenir RStudio à jour afin de bénéficier des dernières fonctionnalités et améliorations. Grâce à cette interface optimisée, RStudio améliore considérablement l’expérience utilisateur et permet aux programmeurs de travailler de manière plus productive et structurée.
L’utilisation de R et RStudio commence par l’installation de ces logiciels sur votre ordinateur. Il est essentiel de télécharger et d’installer les versions compatibles avec votre système d’exploitation (Windows, macOS ou Linux). Voici les étapes à suivre : 1. Téléchargement de R et RStudio Rendez-vous sur le site officiel à l’adresse suivante :https://posit.co/download/rstudio-desktop/. Téléchargez les fichiers d’installation de R et de RStudio, puis procédez à leur installation en suivant les instructions fournies à l’écran. Il est recommandé d’accepter les paramètres par défaut pour une installation standard et optimisée. 2. Installation de RTools (uniquement pour Windows) Si vous utilisez Windows, il est également nécessaire d’installer le logiciel RTools, disponible sur le site suivant :https://cran.r-project.org/bin/windows/Rtools/ RTools est indispensable pour installer et compiler certains packages R directement à partir de leur code source.
En suivant ces étapes, vous serez prêt à utiliser R et RStudio pour vos analyses de données et vos travaux en programmation statistique.
IMPORTANT À NOTER: Lors de l’utilisation de ces outils, seul RStudio sera lancé directement sur votre ordinateur. En revanche, R et RTools s’exécutent en arrière-plan et n’ont pas besoin d’être ouverts manuellement. RStudio agit comme une interface centrale qui facilite l’interaction avec R, tandis que RTools (sur Windows) est utilisé automatiquement lorsque nécessaire, notamment pour l’installation et la compilation de certains packages comme nous l’avons dit ci-haut.
Lorsque vous ouvrez RStudio, l’interface est divisée en quatre volets principaux :
C’est ici que vous écrivez, modifiez et sauvegardez vos scripts ou documents R Markdown. Utilisation : * Écrire et sauvegarder des scripts R (.R) ou des documents R Markdown (.Rmd). * Exécuter une ligne ou un bloc de code en utilisant Ctrl + Enter (Windows/Linux) ou Cmd + Enter (Mac). Fonctions principales : * Numéros de lignes pour une meilleure navigation. * Coloration syntaxique pour identifier les commandes, commentaires, etc. * Onglets multiples pour travailler sur plusieurs fichiers.
La console est la zone où les commandes sont exécutées directement. Elle permet une interaction immédiate avec R. Utilisation : * Saisir des commandes R directement et voir leurs résultats instantanément. * Afficher des messages d’erreur ou des avertissements. * Exemple :
print(“Est-ce tout le monde va bien?”)
Ce volet est dédié à la gestion des objets (données, variables, fonctions) créés pendant la session. * Environment : ** Affiche tous les objets disponibles (comme les variables, tableaux ou fonctions). ** Possibilité de les supprimer ou de les visualiser (par exemple, afficher une table de données dans une vue en tableau). * History : ** Liste des commandes exécutées. ** Permet de rejouer ou copier des commandes passées.
Ce volet regroupe plusieurs fonctionnalités: * Plots : ** Affiche les graphiques générés par vos commandes. ** Options pour sauvegarder, redimensionner ou copier vos graphiques. * Files : ** Explore les fichiers du répertoire de travail. ** Permet de naviguer et de gérer vos fichiers. * Packages : ** Affiche les packages R installés. ** Permet d’installer, charger ou mettre à jour des packages. * Help : ** Fournit une aide détaillée sur les fonctions ou packages (tapez ?fonction pour accéder à la documentation). * Viewer : ** Affiche du contenu HTML (par exemple, les rapports générés avec R Markdown).
Fonctions supplémentaires utiles * Barre de menu (en haut) : Accès rapide aux fonctionnalités comme créer un nouveau fichier, ouvrir un projet ou personnaliser vos paramètres. * Console de débogage (lorsqu’un programme est en cours d’exécution) : Permet de diagnostiquer et de corriger des erreurs dans votre code.
Cette image décrit les principaux volets (fenêtres) de l’interface R studio
Cette image décrit quelques options de la barre de menu
Exemple
Dans le volet Source, taper les commandes suivantes et remarquez ce qui s’affiche dans les autres volets:
?mean()
??ggplot()
v1 = 45 # Le symbole <- est egalement utilisé pour exprimer l'égalité (dans le cadre d'assignation d'une valeur à un objet R).
v2 = 15 # Le symbole <- est obtenu par le racourci clavier Optio + - sur Mac ou ALT + = sur Windows
v3 = 3 # Pour valider une commande R, la sélectionner puis taper CTRL/CMD + ENTER ou cliquer sur RUN dans le voler Source (coin supérieur gauche)
v4 = (v1*v3)/v2
print(v4)
## [1] 9
Un package en R est un ensemble de fonctions, de données et de documentation organisés de manière cohérente pour accomplir des tâches spécifiques et coompler les fonctions de base de R.
Les packages permettent d’étendre les fonctionnalités de base du langage R et d’ajouter des outils supplémentaires pour des domaines spécifiques comme la statistique, la visualisation de données, le machine learning, etc.
Par exemple, le package ggplot2 fournit des fonctions pour créer des graphiques complexes, et le package dplyr offre des outils pour la manipulation de données.
Les principaux composants d’un package incluent :
R dispose d’une grande bibliothèque de packages que vous pouvez installer à partir du CRAN (Comprehensive R Archive Network) ou de sources comme GitHub.
Il existe deux manières d’installer un package: 1. En tapant un script dans le volet Source:
install.packages(“nom_du_package”)
Exemple:
install.packages(“readxl”) Incluant les «dependencies» : install.packages(“nom_du_package”, dependencies = TRUE)
Exemple: install.packages(“showtext”, dependencies = TRUE)
Cette image montre l’installation d’un package à l’aide du menu Tools
Exemple des packages dans R
Un package R n’a besoin d’être installé qu’une seule fois sur votre système, sauf si vous souhaitez le mettre à jour. Cependant, pour l’utiliser dans une session R donnée, il doit être activé/chargé à l’aide de la commande suivante :
library(nom_du_package)
ou équivalent :
library(“nom_du_package”)
Par exemple :
Activation du package ggplot2
library(ggplot2)
Cela permet de charger les fonctionnalités du package dans la session en cours, ce qui le rend immédiatement utilisable. Si vous fermez et rouvrez une session R, vous devrez réactiver les packages nécessaires.
Description du package tidyverse
Le tidyverse est une collection de packages R conçus pour simplifier et normaliser l’analyse des données. Il repose sur une philosophie commune et une syntaxe cohérente pour >manipuler, transformer et visualiser les données de manière intuitive.
Objectifs principaux du tidyverse :
- Simplifier l’analyse des données grâce à une syntaxe intuitive et facile à lire.
- Promouvoir les bonnes pratiques en structurant les données dans un format dit “tidy” : chaque ligne représente une observation, chaque colonne une variable.
- Créer des pipelines efficaces grâce à l’opérateur pipe (%>%), permettant de chaîner plusieurs étapes de transformation sans devoir stocker des variables intermédiaires.
Principaux packages du tidyverse
Le tidyverse comprend plusieurs packages essentiels pour travailler avec des données.
- ggplot2 : Visualisation des données
Permet de créer des graphiques élégants et personnalisables à partir de la grammaire graphique.
library(ggplot2)
data(mtcars) # Charge le dataset intégré
ggplot(mtcars, aes(x = wt, y = mpg)) +
geom_point() +
labs(title = "Consommation d'essence par poids",
x = "Poids (en tonnes)",
y = "Consommation (miles par gallon)")
- dplyr : Manipulation des données
- Fournit des fonctions intuitives pour filtrer, trier, résumer et manipuler des données tabulaires.
library(dplyr)
##
## Attaching package: 'dplyr'
## The following objects are masked from 'package:stats':
##
## filter, lag
## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, union
data(mtcars) # Charge le dataset intégré
mtcars %>%
filter(mpg > 20) %>%
summarise(mean_weight = mean(wt))
## mean_weight
## 1 2.418071
- tidyr : Restructuration des données
- Aide à organiser et réorganiser les données pour les rendre exploitables.
library(tidyr)
data <- tibble(
nom = c("A", "B"),
math = c(80, 90),
science = c(85, 95)
)
data_long <- data %>%
pivot_longer(cols = c(math, science),
names_to = "matière",
values_to = "score")
print(data_long)
## # A tibble: 4 × 3
## nom matière score
## <chr> <chr> <dbl>
## 1 A math 80
## 2 A science 85
## 3 B math 90
## 4 B science 95
- readr : Importation des données
- Permet de lire rapidement des fichiers CSV, TSV ou autres fichiers texte.
library(readr) data <- read_csv(“data.csv”)
- tibble : Amélioration des data frames
- Introduit une version moderne et plus lisible des cadres de données traditionnels.
library(tibble)
tibble(
x = 1:5,
y = x^2
)
## # A tibble: 5 × 2
## x y
## <int> <dbl>
## 1 1 1
## 2 2 4
## 3 3 9
## 4 4 16
## 5 5 25
- stringr : Manipulation des chaînes de caractères
- Simplifie les opérations comme la recherche, la transformation ou la manipulation de textes.
library(stringr)
str_detect(c("cat", "dog"), "ch") # Vérifie si "ch" est présent dans les chaînes
## [1] FALSE FALSE
- forcats : Gestion des facteurs
- Facilite le travail avec des variables catégorielles.
library(forcats)
fct_relevel(factor(c("B", "A", "C")), "A")
## [1] B A C
## Levels: A B C
Installation du tidyverse L’ensemble des packages du tidyverse peut être installé avec une seule commande : install.packages(“tidyverse”) Pour les charger ensuite : library(tidyverse)
Exemple complet avec le tidyverse
Voici un exemple combinant plusieurs packages pour manipuler et visualiser des données :
library(tidyverse) # Chargement des données
## ── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
## ✔ lubridate 1.9.3 ✔ readr 2.1.5
## ✔ purrr 1.0.2
## ── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
## ✖ dplyr::filter() masks stats::filter()
## ✖ dplyr::lag() masks stats::lag()
## ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors
data <- mtcars # Manipuler et visualiser les données
data %>%
filter(mpg > 20) %>% # Filtrer les voitures avec plus de 20 mpg
mutate(kpl = mpg * 0.425144) %>% # Ajouter une colonne avec la consommation en km/L
group_by(cyl) %>% # Regrouper par nombre de cylindres
summarise(avg_kpl = mean(kpl)) %>% # Calculer la consommation moyenne par groupe
ggplot(aes(x = factor(cyl), y = avg_kpl, fill = factor(cyl))) +
geom_col() +
labs(title = "Consommation moyenne par cylindre",
x = "Nombre de cylindres",
y = "Consommation moyenne (km/L)")
help.start(): affiche des liens vers plusieurs ressources d’information et de formation (packages, introduction à R, etc.) Menu Tools > Keyboards Shortcuts Help: pour afficher les raccourcis clavier. ?fonction: pour afficher de l’aide sur une fonction: * Exemple: ?mean ??fonction: pour afficher le package auquel appartient une fonction. * Exemple ??mean help(package=«package_name»): obtenir de l’aide sur un package * Exemple: help(package=«ggplot2»)
setwd(«/chemin/d’accès/au/dossier/de/travail/»): pour indiquer le dossier de travail, où se trouve la base des données et où les résultats (graphiques) seront sauvegardés) getwd(): afficher le chemin d’accès vers le dossier de travail
Manipulations sur une variable quantitaive
#obtenir un résumé avec le package DescTools
install.packages("DescTools", repos="http://cran.rstudio.com/", dependencies=TRUE) # pour installer le package
## Warning: unable to access index for repository http://cran.rstudio.com/src/contrib:
## cannot open URL 'http://cran.rstudio.com/src/contrib/PACKAGES'
## Warning: package 'DescTools' is not available for this version of R
##
## A version of this package for your version of R might be available elsewhere,
## see the ideas at
## https://cran.r-project.org/doc/manuals/r-patched/R-admin.html#Installing-packages
## Warning: unable to access index for repository http://cran.rstudio.com/bin/macosx/big-sur-arm64/contrib/4.4:
## cannot open URL 'http://cran.rstudio.com/bin/macosx/big-sur-arm64/contrib/4.4/PACKAGES'
library(DescTools) # charger le package DescTools
library(tidyverse) # charger le package tidyverse
# créons des fausses donnêes pour la pratique. Les mêmes fonctions peuvent être appliquêes aux vraies données
Input =("v0 v1 v2 v3
12.4 45.15 1.25 1115.2
13.5 26.15 0.99 1216.4
16.3 78.14 1.63 1426.1
14.9 56.35 1.34 1635.2
14.5 65.21 0.96 1345.6
13.9 63.15 1.26 1248.3
18.2 46.15 0.64 1632.5
16.7 48.23 1.54 1458.6
23.2 86.35 1.48 1752.6
10.9 46.15 1.78 1496.8
23.9 31.25 0.69 1835.6
24.8 48.26 1.16 1934.6
26.1 46.23 1.49 1536.4
24.7 32.56 1.25 1269.7")
data = as.data.frame(read.table(textConnection(Input), header=TRUE)) # génère un tableau ou une base de données (=dataframe)
data #visualiser le tableau
## v0 v1 v2 v3
## 1 12.4 45.15 1.25 1115.2
## 2 13.5 26.15 0.99 1216.4
## 3 16.3 78.14 1.63 1426.1
## 4 14.9 56.35 1.34 1635.2
## 5 14.5 65.21 0.96 1345.6
## 6 13.9 63.15 1.26 1248.3
## 7 18.2 46.15 0.64 1632.5
## 8 16.7 48.23 1.54 1458.6
## 9 23.2 86.35 1.48 1752.6
## 10 10.9 46.15 1.78 1496.8
## 11 23.9 31.25 0.69 1835.6
## 12 24.8 48.26 1.16 1934.6
## 13 26.1 46.23 1.49 1536.4
## 14 24.7 32.56 1.25 1269.7
# Fonctions statistiques pour une variable quantitaive x
x = data$v0 # x=data$v0 veut dire que nous assignons à l'objet x les valeurs de la variable vO appartenant au dataframe nommé data
sum(x) # Calcule la somme des valeurs de x
## [1] 254
mean(x) # Calcule la moyenne des valeurs de x
## [1] 18.14286
median(x) # Calcule la médiane des valeurs de x
## [1] 16.5
Mode(x) # Calcule le mode des valeurs de x à partir de Desctool
## [1] NA
## attr(,"freq")
## [1] NA
max(x) # Affiche le maximum des valeurs de x
## [1] 26.1
min(x) # Affiche le minimum des valeurs de x
## [1] 10.9
sd(x) # Calcule l'écart-type des valeurs de x
## [1] 5.288698
var(x) # Calcule la variance des valeurs de x
## [1] 27.97033
quantile(x) # Calcule les qunatiles des valeurs de x
## 0% 25% 50% 75% 100%
## 10.900 14.050 16.500 23.725 26.100
length(x) # Calcule la taille de la variable x
## [1] 14
#t.test(x, y, alternative, mu, paired, var.equal, .)
t.test(x, mu = 5) # comparaison moyenne observée vs moyenne théorique
##
## One Sample t-test
##
## data: x
## t = 9.2983, df = 13, p-value = 4.156e-07
## alternative hypothesis: true mean is not equal to 5
## 95 percent confidence interval:
## 15.08925 21.19646
## sample estimates:
## mean of x
## 18.14286
t.test(data$v0, data$v1) # comparaison deux moyennes observées
##
## Welch Two Sample t-test
##
## data: data$v0 and data$v1
## t = -6.925, df = 15.447, p-value = 4.139e-06
## alternative hypothesis: true difference in means is not equal to 0
## 95 percent confidence interval:
## -43.44248 -23.03323
## sample estimates:
## mean of x mean of y
## 18.14286 51.38071
t.test(data$v0, data$v1, paired = TRUE, var.equal = TRUE) # paired t-test:cannot compute exact p-value with ties
##
## Paired t-test
##
## data: data$v0 and data$v1
## t = -6.7733, df = 13, p-value = 1.315e-05
## alternative hypothesis: true mean difference is not equal to 0
## 95 percent confidence interval:
## -43.83912 -22.63660
## sample estimates:
## mean difference
## -33.23786
#U-test wilcox.test(x, y, alternative, mu, paired, .)
wilcox.test(data$v0, data$v1) #Warning message:In wilcox.test.default(data$v0, data$v1) :
## Warning in wilcox.test.default(data$v0, data$v1): cannot compute exact p-value
## with ties
##
## Wilcoxon rank sum test with continuity correction
##
## data: data$v0 and data$v1
## W = 0, p-value = 7.446e-06
## alternative hypothesis: true location shift is not equal to 0
wilcox.test(data$v0, data$v1, exact = FALSE)
##
## Wilcoxon rank sum test with continuity correction
##
## data: data$v0 and data$v1
## W = 0, p-value = 7.446e-06
## alternative hypothesis: true location shift is not equal to 0
# Test de l'homogénéité des variances et de la noramalité
#Regarder à la distribution grâce à un graphique
library("ggpubr")
ggdensity(data$v0,
main = "Density plot of v0",
xlab = "v0") # trace un graphique de la variable
ggqqplot(data$v0) #
# Shapiro-Wilk test pour une distribution individuelle
shapiro.test(data$v0)
##
## Shapiro-Wilk normality test
##
## data: data$v0
## W = 0.8892, p-value = 0.07871
shapiro.test(data$v1)
##
## Shapiro-Wilk normality test
##
## data: data$v1
## W = 0.9372, p-value = 0.3837
### La distribution suit la loi normale lorsque la valeur de p est >0,05
######################”
Test de Chi-carré
Input2 =("
Patient Pf Pm Pv Po Pk Gender Education
SLV1 47 10 40 2 2 M Yes
SLV2 19 3 5 0 2 M No
SLV3 50 0 10 7 0 F Yes
SLV4 46 16 8 4 0 F No")
data2 = as.data.frame(read.table(textConnection(Input2), header=TRUE))
data2
## Patient Pf Pm Pv Po Pk Gender Education
## 1 SLV1 47 10 40 2 2 M Yes
## 2 SLV2 19 3 5 0 2 M No
## 3 SLV3 50 0 10 7 0 F Yes
## 4 SLV4 46 16 8 4 0 F No
#créer une nouvelle variable
data2 = data2 %>% mutate(Pm01=case_when(Pm==0 ~ "Negative",
Pm>0 ~ "Positive"))
table(data2$Pm01,data2$Gender)
##
## F M
## Negative 1 0
## Positive 1 2
#make a 2x2 table
cs = chisq.test(table(data2$Pm01,data2$Gender))
## Warning in chisq.test(table(data2$Pm01, data2$Gender)): Chi-squared
## approximation may be incorrect
cs
##
## Pearson's Chi-squared test with Yates' continuity correction
##
## data: table(data2$Pm01, data2$Gender)
## X-squared = 0, df = 1, p-value = 1
Créer des graphiques de qualité avec R
Aperçu sur la création des graphiques dans R
Règles * Nombre de variables à tracer ; => type de variable : catégorielle, continue, temporelle, etc. ** 1 variable: *** Si variable catégorielle : on peut tracer histogrammes, diagrammes à secteurs *** Si variable continue : tracés d’index, tracés de séries temporelles, ** 2 variables: *** Si variables catégorielles : histogrammes *** Si 1 catégorielle, 1 continue : boxplot ou barplot *** Si 2 continues : nuages de points
Outils
Graphiques de base R: graphiques basiques pas très grande qualité. Packages de traçage de graphiques dans R (par exemple ggplot2): génère des graphiques de grande qualité et hautement personnalisable.
Types de tracés
Importation des donées
library(readxl) # package qui permet d'important une base des données Excel ou csv. Si le package n'est pas installé, l'installer.
setwd("/Volumes/MySD24933/Administration/UM") # spécifie le répertoire ou dossierde travail et oú se trouve la base des données. À spécifier en fonction de sa machine
getwd() # affiche le répertoire de travail
## [1] "/Volumes/MySD24933/Administration/UM"
df <- read_excel("base_exercicesurR.xlsx", sheet = "base_exercicesurR", na = "") # commande intégrée à readxl permettant l'importation des données excel.
#View(df) # affiche la base des données
tail(df) # affiche les 6 derniéres données de la base des données
## # A tibble: 6 × 8
## Hp1 Res1 Hp2 Res2 Sexe Age Statut_marital disease
## <dbl> <dbl> <dbl> <dbl> <chr> <dbl> <chr> <dbl>
## 1 97.6 1 86.8 1 Masculin 29 Marie 1
## 2 99.1 1 88.4 1 Masculin 27 Marie 1
## 3 81.7 1 89.6 1 Masculin 41 Marie 1
## 4 86.7 1 91.9 1 Féminin 29 Célibataire 1
## 5 51.7 1 92.9 1 Féminin 69 Veuf 1
## 6 86.2 1 97.4 1 Masculin 55 Veuf 1
head(df) # affiche les 6 premières données de la base des données
## # A tibble: 6 × 8
## Hp1 Res1 Hp2 Res2 Sexe Age Statut_marital disease
## <dbl> <dbl> <dbl> <dbl> <chr> <dbl> <chr> <dbl>
## 1 10.8 0 10 0 Féminin 27 Marie 0
## 2 8.6 0 10 0 Masculin 34 Marie 0
## 3 13.1 0 10.1 0 Féminin 49 Marie 0
## 4 13.7 0 10.2 0 Masculin 67 Marie 0
## 5 8.2 0 10.2 0 Féminin 48 Marie 0
## 6 11.5 0 10.3 0 Féminin 43 Marie 0
str(df) # affiche la structure des données de la base des données
## tibble [425 × 8] (S3: tbl_df/tbl/data.frame)
## $ Hp1 : num [1:425] 10.8 8.6 13.1 13.7 8.2 11.5 14.2 7 11.8 15.1 ...
## $ Res1 : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
## $ Hp2 : num [1:425] 10 10 10.1 10.2 10.2 10.3 10.4 10.5 10.6 10.7 ...
## $ Res2 : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
## $ Sexe : chr [1:425] "Féminin" "Masculin" "Féminin" "Masculin" ...
## $ Age : num [1:425] 27 34 49 67 48 43 30 22 25 70 ...
## $ Statut_marital: chr [1:425] "Marie" "Marie" "Marie" "Marie" ...
## $ disease : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
Fonctions pour tracer les graphqies
Créer un Scatter Plot
Avec les fonctions basiques de R: synthaxe: plot(y~x) ou plot(y,x)
Exemple:
plot(df$Hp1, df$Hp2)
Avec ggplot : synthaxe: qplot(x, y) ou ggplot() + geom_point()
Exeemple:
qplot(df$Hp1, df$Hp2)
## Warning: `qplot()` was deprecated in ggplot2 3.4.0.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
qplot(Hp1, Hp2, data=df)
ggplot(df, aes(x=Hp1, y=Hp2)) + geom_point()
Créer un Line Graph
Avec les fonctions basiques de R: synthaxe : plot(y,x, type=“l”)
Exemple:
plot(df$Hp1, df$Hp2, type="p")
plot(df$Hp1, df$Hp2, type="l")
plot(df$Hp1, df$Hp2, type="b")
plot(df$Hp1, df$Hp2, type="l")
points(df$Hp1, df$Hp2)
lines(df$Hp1, df$Hp2/2, col="red")
points(df$Hp1, df$Hp2/2, col="red")
Avce ggplot: syntaxes: qplot(x, y, geom=“line”) ou ggplot() + geom_line() qplot(df\(Hp1, df\)Hp2, geom=“line”)
ggplot(df, aes(x=Hp1, y=Hp2)) + geom_line()
ggplot(df, aes(x=Hp1, y=Hp2)) + geom_point()
ggplot(df, aes(x=Hp1, y=Hp2)) + geom_line() + geom_point()
qplot(Hp1, Hp2, data=df, geom=c("line", "point"))
Créer un graphique à barres
Avec les fonctions basiques de R:
Exemple:
#par(mfrow=c(1,2))
barplot(table(df$Statut_marital))
#par(mfrow=c(1,1))
Avec ggplot
Exemple:
qplot(df$Hp1)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
qplot(df$Sexe)
qplot(factor(df$Statut_marital))
qplot(factor(Statut_marital), data=df)# Bar graph des comptes
ggplot(df, aes(x=factor(Statut_marital))) + geom_bar() # son équivalent
Créer un histogramme
Avec les fonctions basiques de R:
Exemple:
par(mfrow=c(2,2))
hist(df$Hp1)
hist(df$Hp1, breaks=5)# Specify approximate number of bins with breaks
par(mfrow=c(1,1))
Avec ggplot:
Exemple:
qplot(df$Hp2)
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
qplot(Hp2, data=df, binwidth=4) #define the binwidth
qplot(Statut_marital, data=df, binwidth=4)
## Warning in geom_bar(binwidth = 4): Ignoring unknown parameters: `binwidth`
ggplot(df, aes(x=Hp1)) + geom_histogram()
## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
ggplot(df, aes(x=Hp1)) + geom_histogram(binwidth=4)#define the binwidth
Créer un boxplot (diagramme à moustache)
Avec les fonction basiques de R:
Exemple:
boxplot(Hp2 ~ Statut_marital, data = df)
boxplot(Hp1 ~ Sexe, data = df)
Avec ggplot:
Exemple:
qplot(df$Statut_marital, df$Hp2, geom="boxplot")
qplot(Statut_marital, Hp2, data=df, geom="boxplot") #two vectors are already in the same data frame
ggplot(df, aes(x=Statut_marital, y=Hp2)) + geom_boxplot() #Idem
qplot(interaction(df$Statut_marital, df$Hp1), df$Hp2, geom="boxplot")
Tracer une courbe de fonction
Avec les fonction basiques de R:
curve(x^3 - 5*x, from=-4, to=4)#simple curve
myfun <- function(xvar) {# Plot a user-defined function
1/(1 + exp(-xvar + 10))
}
curve(myfun(x), from=0, to=20)#Plot a curve
curve(1-myfun(x), add = TRUE, col = "red")# Add a line:
Avec ggplot:
ggplot(data.frame(x=c(0, 20)), aes(x=x)) + stat_function(fun=myfun, geom="line") #Idem
ggplot2 est un package de visualisation de données pour le langage R, l’un des plus élégant et polyvalent. Il repose sur la Grammaire des graphiques (Grammar of Graphics), une approche systématique pour construire des graphiques complexes en combinant des couches. ggplot2 divise les graphiques en plusieurs composants (données, esthétique, géométrie, etc.), que l’utilisateur peut combiner pour créer des visualisations personnalisées.
Un graphique ggplot est construit en étapes ou couches avec cette syntaxe de base :
ggplot(data = data_frame, aes(x = x_variable, y = y_variable)) + geom_fonction() + options supplémentaires
Autrement:
ggplot(data = DATA) + GEOM_FUNCTION(mapping = aes(MAPPINGS), stat = STAT, position = POSITION) + COORDINATE_FUNCTION + FACET_FUNCTION
Le jeu de données (data), les esthétiques (aes) et la géométrie (geom) sont des paramètres obligatoires pour tracer un graphique avec ggplot2. Les autres paramètres sont facultatifs mais contribuent hautement à l’élégance du graphique.
ggplot2 permet de personnaliser quasiment tous les aspects des graphiques :
Dans les exemples qui vont suivre, nous allons soit utiliser la base des données importées ci-haut (et qui sera rendu disponible pour raisons d’exercice) “base_exercicesurR.xlsx” ou les bases des données intégrées aux packages R, ou des jeux de fausses données crées.
ggplot2 fait partie des packages de base de tidyverse. Si ce dernier est déjà installé, il suffira de le charger (activer) et les fonctions de ggplot2 seront utilisables. Cepdendant, ggplot2 peut être installé et chargé séparément en utilisant les commades:
install.packages("ggplot2")
library(ggplot2)
Dans cet exemple, nous souhaitons évaluer dans quelle mesure les résultats des deux tests, Hp1 et Hp2, sont corrélés pour détecter une infection. Cette corrélation peut être visualisée à l’aide d’un nuage de points. Les deux tests présentent une corrélation positive si les points tendent à se regrouper le long de la diagonale. Le nuage de points peut être représenté à l’aide de l’option geom_point du package ggplot2. Dans la commande, il est indispensable de spécifier le jeu de données (data) ainsi que le mapping des variables esthétiques (aes). Les autres paramètres seront automatiquement gérés par R en utilisant les options par défaut, à moins qu’ils ne soient explicitement définis dans la commande.
library(readxl) # package qui permet d'important une base des données Excel ou csv. Si le package n'est pas installé, l'installer.
setwd("/Volumes/MySD24933/Administration/UM") # spécifie le répertoire ou dossierde travail et oú se trouve la base des données. À spécifier en fonction de sa machine
getwd() # affiche le répertoire de travail
## [1] "/Volumes/MySD24933/Administration/UM"
df <- read_excel("base_exercicesurR.xlsx", sheet = "base_exercicesurR", na = "") # df est nom du jeu de données (data frame) ou base des données à être utilisé.
names(df) # affiche les noms de variables
## [1] "Hp1" "Res1" "Hp2" "Res2"
## [5] "Sexe" "Age" "Statut_marital" "disease"
str(df) # affiche le type de variables et quelques données pour chaque variable (structure des variables)
## tibble [425 × 8] (S3: tbl_df/tbl/data.frame)
## $ Hp1 : num [1:425] 10.8 8.6 13.1 13.7 8.2 11.5 14.2 7 11.8 15.1 ...
## $ Res1 : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
## $ Hp2 : num [1:425] 10 10 10.1 10.2 10.2 10.3 10.4 10.5 10.6 10.7 ...
## $ Res2 : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
## $ Sexe : chr [1:425] "Féminin" "Masculin" "Féminin" "Masculin" ...
## $ Age : num [1:425] 27 34 49 67 48 43 30 22 25 70 ...
## $ Statut_marital: chr [1:425] "Marie" "Marie" "Marie" "Marie" ...
## $ disease : num [1:425] 0 0 0 0 0 0 0 0 0 0 ...
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) # Hp1 et Hp2 sont deux variables quantitatives qui représentent les résultats de deux tests de dosage.
On peut observer dans la figure ci-dessus que les points tendent à se regrouper autour de la diagonale, ce qui indique une certaine corrélation entre les tests Hp1 et Hp2.
Avec ggplot2, vous commencez un tracé avec la fonction ggplot(). ggplot() crée un système de coordonnées auquel vous pouvez ajouter des calques ou couches. Le premier argument de ggplot() est le jeu de données à utiliser dans le graphique. Ainsi, ggplot(data = df) crée un graphique vide, consititué uniquement du systéme de coordonées ou des axes. Vous complétez votre graphique en ajoutant un ou plusieurs calques/couches à ggplot(). La fonction geom_point() ajoute une couche de points à votre tracé, ce qui crée un nuage de points. ggplot2 est fourni avec de nombreuses fonctions geom qui ajoutent chacune un type de calque différent à un tracé, un peu comme nous l’avons mentionné ci-haut. Chaque fonction geom dans ggplot2 prend un argument mapping qui définit comment les variables du jeu de données sont mappées aux propriétés visuelles. L’argument mapping est toujours associé à aes(), et les arguments x et y de aes() spécifient les variables à mapper aux axes x et y. ggplot2 recherche la variable mappée dans l’argument de données, dans ce cas, df.
La syntaxe de base pour tracer un graphique avec ggplot2 es présente donc comme ceci:
ggplot(data = ) +
(mapping = aes( ))
Décortiquons cette syntaxe en commençans avec le paramétre ou l’élément mapping.
Le paramètre esthétique (aesthetic) fait référence à une propriété visuelle des éléments du graphique. Il englobe des aspects tels que la taille, la forme ou la couleur des points. Vous pouvez personnaliser l’apparence des points en modifiant les valeurs de ces propriétés esthétiques. Le terme « niveau » est utilisé pour désigner les variations de ces propriétés. Par exemple, les niveaux de taille, de forme et de couleur d’un point peuvent être ajustés pour qu’il devienne petit, triangulaire ou bleu, entre autres.
Vous pouvez transmettre des informations sur vos données en associant les propriétés esthétiques de votre tracé aux variables de votre jeu de données. Par exemple, il est possible de mapper la couleur des points à une variable telle que le sexe, afin de visualiser le genre de chaque participant pour lequel les résultats des tests sont présentés:
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe))
Pour mapper une esthétique à une variable, associez le nom de l’esthétique (par exemple:x, y, color, shape, size, alpha, etc.) au nom de la variable à l’intérieur de aes(). ggplot2 attribuera automatiquement un niveau unique de l’esthétique (ici une couleur unique) à chaque valeur unique de la variable, un processus connu sous le nom de mise à l’échelle (scaling). ggplot2 ajoutera également une légende qui explique quels niveaux correspondent à quelles valeurs.
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe, size = Age)) # l'esthétique size gère la taille d'affichage de la variable numérique à laquelle elle est mappée
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe, alpha = Age))
# l'esthétique alpha gère la transparence d'affichage de la variable numérique à laquelle elle est mappée
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe, shape = Statut_marital))
# l'esthétique shape gère la fome d'affichage de la variable qualitative à laquelle elle est mappée
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2), color = "pink") # On peu ausi afficher tous les point en rose.
Remarquez la hiérarchie des parenthèses. En effet, dés lors que l’esthétique color ne se mappe avec aucune variable du jeu de données, elle doit être en dehors de aes(). Dans ce cas, la couleur ne se réfère pas à une variable en particulier mais correspond à l’apparence générale du graphique. C’est la même chose lorsqu’on veut donner aux points d’autres formes que les cerceles affichés par défaut; de même lorsqu’on veut personnaliser la taille des fromes.
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2, color = Sexe), shape=9, size = 8)
# Lorsque shape renvoie à l'allure générale du graphique, il doit être spécifié en termes de numéros variants de 0 à 24.
# Remarquez également la taille des formes ajustée à 8.
La fonction supplémentaire et facultaive facet() permet de présenter un même graphique en fonction d’autre d’une variable qualitative. Nous pouvons tracer les nuages des points pour Hp1 et Hp2 par sexe et par statut marital par exemple:
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_wrap(~ Sexe, nrow = 2) # nrow = 2 veut dire que le nombre de lignes est de 2, soit une figure au dessus et une autre en bas.
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_wrap(~ Sexe, ncol = 2) # ncol = 2 veut dire que le nombre de colonnes est de 2, soit une figure à gauche et une autre à droite.
On peut aussi éclater un même type de figure en fonction de deux variables qualitatives. Par exemple nuage des points de Hp1 et Hp2 en fonction des variables Sexe et Statut_marital. Il faut alors utiliser la fonction facet_grid() et y ajouter les deux variables qualitatives sépérées par le ~.
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_grid(Sexe ~ Statut_marital)
Remarquez ci-dessus les autres applications de fonction facet_grid() lorsque l’une des variables est remplacée par un “.”.
# Premier cas de figure:
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_grid(. ~ Statut_marital)
# Deuxiéme cas de figure:
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
facet_grid(Statut_marital ~ .)
Un geom est l’objet géométrique qu’un tracé utilise pour représenter des données. Les gens décrivent souvent les tracés par le type de geom qu’il utilise. Par exemple, les graphiques à barres utilisent des geoms à barres, les graphiques linéaires utilisent des geoms à lignes, les boxplots utilisent des geoms à boîtes, etc. Les nuages de points utilisent le geom de point. Différents geoms peuvent être utilisés pour tracer les mêmes données. Pour modifier le geom dans un tracé, modifiez la fonction geom que vous ajoutez à ggplot().
Dans les figures qui suivent, le premier tracé utilise le geom de point et le deuxième tracé utilise le geom lisse, une ligne lisse adaptée aux données, le troisième est une combinaison des deux et le quatrième une combinaison de deux premiers avec la ligne tracée en fonction du sexe
# Premier tracé
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2))
# Deuxième tracé
ggplot(data = df) +
geom_smooth(mapping = aes(x = Hp1, y = Hp2))
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
# Combinaison de deux
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
geom_smooth(mapping = aes(x = Hp1, y = Hp2))
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
# Combinaison de deux avec la ligne tracée en fonction du sexe
ggplot(data = df) +
geom_point(mapping = aes(x = Hp1, y = Hp2)) +
geom_smooth(mapping = aes(x = Hp1, y = Hp2, linetype = Sexe))
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
Cependant, la combinaison de geoms comme dans les deux derniers tracés peut entraîner une certaine duplication dans le code. Par exemple, si l’on souhaite modifier l’axe des Y pour afficher Age au lieu de Hp2, il faudrait modifier la variable à deux endroits, ce qui augmente le risque d’oublier une mise à jour. Pour éviter ce type de répétition, il est possible de passer un ensemble de mappages directement à la fonction ggplot(). Ces mappages seront alors traités comme des mappages globaux, s’appliquant automatiquement à chaque geom du graphique.
Exemple:
ggplot(data = df, mapping = aes(x = Hp1, y = Hp2)) + geom_point() + geom_smooth()
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
Autres exemples de codes (remarquez la différence entre les fonctions group et color):
# Exemple premier
ggplot(data = df) +
geom_smooth(mapping = aes(x = Hp1, y = Hp2, group = Sexe))
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
# Exemple deuxiéme
ggplot(data = df) +
geom_smooth(
mapping = aes(x = Hp1, y = Hp2, color = Sexe),
show.legend = FALSE
)
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
On peut aussi, en combinant plusieurs geoms, décider des données à afficher dans le tracé en utilisant par exemple la fonction filter.
# Exemple premier
ggplot(data = df, mapping = aes(x = Hp1, y = Hp2)) +
geom_point(mapping = aes(color = Sexe)) +
geom_smooth(
data = filter(df, disease == "1"),
se = FALSE
)
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
# Exemple deuxième
ggplot(data = df, mapping = aes(x = Hp1, y = Hp2)) +
geom_point(mapping = aes(color = Sexe)) +
geom_smooth(
data = filter(df, disease == 0),
se = FALSE,
color="black",
linewidth=4
)
## `geom_smooth()` using method = 'loess' and formula = 'y ~ x'
Le terme stat, abréviation de statistical transformation, désigne l’algorithme employé pour calculer de nouvelles valeurs destinées à un graphique. Chaque geom possède une transformation statistique par défaut (stat), et, inversement, chaque stat est associée à un geom par défaut. Ainsi, ces deux éléments peuvent généralement être utilisés de manière interchangeable, ce qui permet d’employer un geom sans nécessairement se préoccuper de la transformation statistique sous-jacente.
Prenons l’exemple de la fonction geom_bar(). La documentation associée (?geom_bar) révèle que la valeur par défaut de stat est count. En conséquence, l’utilisation de geom_bar() revient à recourir implicitement à stat_count(). Ainsi, les deux lignes de code suivantes produisent des résultats équivalents:
ggplot(data = df) + stat_count(mapping = aes(x = Statut_marital))
ggplot(data = df) + geom_bar(mapping = aes(x = Statut_marital))
Cependant, il existe trois situations où l’usage explicite d’une transformation statistique (stat) peut s’avérer nécessaire ou pertinent: * Modifier la statistique par défaut : Par exemple, dans le code suivant, la transformation statistique par défaut de geom_bar(), à savoir count, est remplacée par identity. Cette substitution permet de mapper la hauteur des barres à des valeurs brutes d’une variable y.
demo <- tribble(
~a,
~b,
"bar_1", 20,
"bar_2", 30,
"bar_3", 40
)
print(demo)
## # A tibble: 3 × 2
## a b
## <chr> <dbl>
## 1 bar_1 20
## 2 bar_2 30
## 3 bar_3 40
ggplot(data = demo) +
geom_bar(
mapping = aes(x = a, y = b), stat = "identity"
)
ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, y = after_stat(prop), group = 1) # "after_stat(prop)" remplace "..prop.." devenu obsolète.
)
ggplot(data = df) +
stat_summary(
mapping = aes(x = Statut_marital, y = Age),
fun.ymin = min,
fun.ymax = max,
fun.y = median
)
## Warning: The `fun.y` argument of `stat_summary()` is deprecated as of ggplot2 3.3.0.
## ℹ Please use the `fun` argument instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
## Warning: The `fun.ymin` argument of `stat_summary()` is deprecated as of ggplot2 3.3.0.
## ℹ Please use the `fun.min` argument instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
## Warning: The `fun.ymax` argument of `stat_summary()` is deprecated as of ggplot2 3.3.0.
## ℹ Please use the `fun.max` argument instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
Autre exemple avec taille barres ajustée à y.
ggplot(data = df) +
geom_bar(mapping = aes(x = Statut_marital, y = after_stat(prop)))
ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, fill = Sexe, y = after_stat(prop))
)
On peut colorer un graphique à barres en utilisant soit l’esthétique des couleurs, soit, plus utilement, la fonction fill (remplissage).
ggplot(data = df) +
geom_bar(mapping = aes(x = Sexe, color = Statut_marital))
ggplot(data = df) +
geom_bar(mapping = aes(x = Sexe, fill = Statut_marital))
# Notez que lorsque l'esthétique de remplissage "fill" est mappée à une autre variable, comme "Statut_marital", les barres sont automatiquement empilées (stacked bar chart).
L’empilement (stacking) des barres est réalisé automatiquement grâce à l’ajustement de position défini par l’argument position. Si on souhaite éviter l’affichage sous forme de barres empilées (stacked bars), il est possible de recourir à l’une des trois options suivantes pour l’argument position :identity, dodge ou fill. * position = “identity” : Cette option positionne chaque objet exactement à sa place dans le contexte du graphique, sans aucun ajustement supplémentaire. Cependant, pour les graphiques à barres, cette méthode entraîne souvent un chevauchement des barres, ce qui peut nuire à la lisibilité. Afin de mieux visualiser ce chevauchement, plusieurs solutions peuvent être envisagées: ** Rendre les barres partiellement transparentes : Cela peut être réalisé en attribuant une petite valeur à l’argument alpha. ** Rendre les barres entièrement transparentes : Cette approche consiste à définir fill = NA.
ggplot(
data = df,
mapping = aes(x = Statut_marital, fill = Sexe)
) +
geom_bar(alpha = 1/5, position = "identity")
ggplot(
data = df,
mapping = aes(x = Statut_marital, color = Sexe)
) +
geom_bar(fill = NA, position = "identity")
En utilisant cette méthode, chaque segment d’une barre représente une proportion relative, permettant ainsi d’examiner des distributions comparatives tout en éliminant l’influence des variations absolues des effectifs entre les groupes.
ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, fill = Sexe),
position = "fill"
)
Cette méthode est particulièrement utile lorsqu’il s’agit de comparer directement des sous-groupes au sein de différentes catégories, tout en évitant l’encombrement visuel associé à l’empilement ou au chevauchement.
ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, fill = Sexe),
position = "dodge"
)
Les systèmes de coordonnées constituent probablement l’un des aspects les plus complexes de ggplot2. Par défaut, le package utilise le système de coordonnées cartésiennes, où les positions sur les axes x et y sont déterminées indépendamment afin de localiser chaque point sur le graphique. Cependant, ggplot2 propose plusieurs systèmes alternatifs qui peuvent s’avérer utiles dans des contextes spécifiques : * coord_flip() : Cette fonction permet d’inverser les axes x et y. Elle est particulièrement utile pour certaines visualisations, comme les boîtes à moustaches horizontales (horizontal boxplots). De plus, elle offre une solution élégante pour les graphiques comportant des étiquettes longues; en effet, ces dernières sont souvent difficiles à ajuster sans chevauchement sur l’axe des x.
ggplot(data = df, mapping = aes(x = Statut_marital, y = Age)) +
geom_boxplot()
ggplot(data = df, mapping = aes(x = Statut_marital, y = Age)) +
geom_boxplot() +
coord_flip()
nz <- map_data("nz")
ggplot(nz, aes(long, lat, group = group)) +
geom_polygon(fill = "white", color = "black")
ggplot(nz, aes(long, lat, group = group)) +
geom_polygon(fill = "white", color = "black") +
coord_quickmap()
En transformant les barres rectangulaires en segments circulaires, les coordonnées polaires permettent de représenter les données d’une manière qui met en valeur des motifs ou des proportions d’une façon souvent plus intuitive ou esthétiquement frappante. Cette méthode est particulièrement utile pour les visualisations où les relations angulaires ou radiales entre les données sont importantes.
bar <- ggplot(data = df) +
geom_bar(
mapping = aes(x = Statut_marital, fill = Sexe),
show.legend = FALSE,
width = 1
) +
theme(aspect.ratio = 1) +
labs(x = NULL, y = NULL)
bar + coord_flip()
bar + coord_polar()
Dans ggplot2, le paramètre theme() permet de modifier les éléments graphiques non liés aux données, comme : * Le fond du graphique, * Les grilles, * Les axes (titre, étiquettes, graduation), * La légende, * Le texte, la taille et les couleurs.
Syntaxe de base :
ggplot(data, aes(x, y)) + geom_point() + theme(…)
** Structure et Composants de theme()**
La fonction theme() contrôle chaque élément du graphique via des éléments thématiques appelés *element_**. Voici les principaux :
Exemple:
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
theme(
panel.background = element_rect(fill = "lightblue"), # Fond du panneau
plot.background = element_rect(fill = "gray90") # Fond global
)
Exemple :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
theme(
axis.title.x = element_text(color = "blue", size = 14, face = "bold"), # Titre de l'axe X
axis.text.y = element_text(color = "red", size = 12) # Étiquettes de l'axe Y
)
Exemple :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
labs(title = "Correlation entre les deux tests", subtitle = "Résultats numériques du test Hp2 comparé au test Hp1") +
theme(
plot.title = element_text(size = 18, face = "bold", hjust = 0.5), # Centrer et styliser le titre
plot.subtitle = element_text(size = 14, face = "italic", hjust = 0.5) # Sous-titre en italique
)
Exemple :
ggplot(df, aes(Hp1, Hp2, color = Sexe)) +
geom_point() +
theme(
legend.position = "bottom", # Légende en bas
legend.background = element_rect(fill = "gray90"), # Fond de la légende
legend.title = element_text(face = "bold"), # Titre en gras
legend.text = element_text(size = 10) # Texte plus petit
)
Vous pouvez supprimer ou styliser les grilles :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
theme(
panel.grid.major = element_line(color = "gray", linetype = "dotted"), # Grille principale
panel.grid.minor = element_blank() # Suppression des grilles secondaires
)
Thèmes Prédéfinis
ggplot2 offre des thèmes prêts à l’emploi, qui modifient automatiquement l’apparence générale du graphique :
Principaux thèmes : * theme_gray() (par défaut) : Fond gris avec grilles blanches. * theme_bw() : Fond blanc avec des grilles noires. * theme_minimal() : Design épuré avec des grilles légères. * theme_classic() : Fond blanc avec des axes classiques. * theme_void() : Supprime tout sauf le tracé.
Exemple :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
theme_minimal() # Application du thème minimaliste
Combinaison plusieurs modifications
Vous pouvez combiner les ajustements dans une seule commande theme() pour un contrôle total :
Exemple
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
theme_minimal() + # Base avec un thème minimaliste
theme(
plot.title = element_text(size = 16, face = "bold", hjust = 0.5),
axis.text.x = element_text(color = "blue"),
axis.ticks = element_line(color = "red"),
panel.grid.major = element_line(color = "gray", linetype = "dotted")
)
Pour voir la liste complète des options disponibles, utilisez : ?theme
Dans ggplot2, les paramètres scale_x_ et scale_y_ permettent de contrôler l’échelle et l’apparence des axes X et Y. Ils jouent un rôle essentiel pour personnaliser :
Les types de fonctions scale_x et scale_y
Ces fonctions permettent de gérer deux aspects principaux : * Limites et transformation des axes (par ex. scale_x_continuous pour les axes numériques). * Ajustement des données catégoriques ou discrètes (par ex. scale_x_discrete pour les axes avec des catégories(variable qualitative)).
Les variantes de scale_x et scale_y : * scale_x_continuous et scale_y_continuous : Pour des données numériques continues. * scale_x_discrete et scale_y_discrete : Pour des données qualitatives (facteurs). * scale_x_log10 et scale_y_log10 : Pour une échelle logarithmique. * scale_x_reverse et scale_y_reverse : Pour inverser l’axe. * scale_x_date et scale_y_date : Pour les axes temporels (dates). * scale_x_datetime et scale_y_datetime : Pour les données de type date-heure. * scale_x_sqrt et scale_y_sqrt : Pour une échelle basée sur la racine carrée.
** Paramètres des fonctions scale_x_* et scale_y_*
Voici les paramètres principaux disponibles pour personnaliser les axes :
scale_x_continuous(limits = c(min, max))
Exemple :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
scale_x_continuous(limits = c(0, 600)) + # Bornes de l'axe X entre 0 et 600
scale_y_continuous(limits = c(0, 600)) # Bornes de l'axe Y entre 0 et 600
scale_x_continuous(breaks = c(1, 2, 3, 4, 5))
Exemple :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
scale_x_continuous(breaks = seq(0, 500, by = 50)) # Graduation tous les 50 sur X
scale_x_continuous(labels = c(“petit”, “moyen”, “grand”))
Exemple :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
scale_x_continuous(breaks = c(100, 200, 300), labels = c("Bas", "Moyen", "Elevé")) # Étiquettes personnalisées
Exemple :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
scale_x_continuous(trans = "log10") # Transformation logarithmique pour l'axe X
Exemple avec expand et name :
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
scale_x_continuous(name = "Résultat du test de référence", expand = c(0, 0))+ # Titre personnalisé pour l'axe X
scale_y_continuous(expand = c(0,0))
Les fonctions scale_x_discrete et scale_y_discrete permettent de personnaliser les axes avec des catégories (facteurs ou chaînes de caractères).
Exemples : * Réorganiser les catégories :
ggplot(df, aes(Sexe, Age)) +
geom_boxplot() +
scale_x_discrete(limits = c("Masculin", "Féminin")) # Ordre personnalisé, au lieu de l'ordre par défaur qui est alphabétique
ggplot(df, aes(Sexe, Age)) +
geom_boxplot() +
scale_x_discrete(limits = c("Masculin", "Féminin"),
labels = c("Messieurs", "Mesdames")) # Étiquettes personnalisées
Exemple 1 : Limites et graduations personnalisées
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
scale_x_continuous(limits = c(50, 300), breaks = seq(50, 300, by = 50)) + # Limites et graduations X
scale_y_continuous(limits = c(40, 240), breaks = seq(40, 240, by = 40)) # Limites et graduations Y
## Warning: Removed 340 rows containing missing values or values outside the scale range
## (`geom_point()`).
Exemple 2 : Transformation logarithmique
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
scale_x_log10() + # Échelle logarithmique pour X
scale_y_continuous(trans = "sqrt") # Racine carrée pour Y
Exemple 3 : Axes inversés
ggplot(df, aes(Hp1, Hp2)) +
geom_point() +
scale_x_reverse() + # Inverser l'axe X
scale_y_reverse() # Inverser l'axe Y
Pour plus d’information, taper: ?scale_x_continuous ou ?scale_x_discrete
Le graphique ci-dessous présente les variables Sexe, Hp1 et Statut matrimonial du jeu de données fourni “base_exercicesurR.xlsx”. Question: Générer le code R ayant permis de le tracer.